// RAP [rh] DnD not supported
///*******************************************************************************
// * Copyright (c) 2004, 2007 IBM Corporation and others.
// * All rights reserved. This program and the accompanying materials
// * are made available under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution, and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// * IBM Corporation - initial API and implementation
// *******************************************************************************/
//package org.eclipse.ui.internal;
//
//import java.util.Iterator;
//import java.util.List;
//
//import org.eclipse.jface.util.Geometry;
//import org.eclipse.swt.SWT;
//import org.eclipse.swt.graphics.Cursor;
//import org.eclipse.swt.graphics.Point;
//import org.eclipse.swt.graphics.Rectangle;
//import org.eclipse.swt.widgets.Composite;
//import org.eclipse.swt.widgets.Control;
//import org.eclipse.ui.internal.dnd.DragBorder;
//import org.eclipse.ui.internal.dnd.DragUtil;
//import org.eclipse.ui.internal.dnd.IDragOverListener;
//import org.eclipse.ui.internal.dnd.IDropTarget;
//import org.eclipse.ui.internal.dnd.IDropTarget2;
//import org.eclipse.ui.internal.layout.IWindowTrim;
//import org.eclipse.ui.internal.layout.LayoutUtil;
//import org.eclipse.ui.internal.layout.TrimDescriptor;
//import org.eclipse.ui.internal.layout.TrimLayout;
//import org.eclipse.ui.internal.layout.TrimToolBarBase;
//
///**
// */
///*package*/class TrimDropTarget implements IDragOverListener {
//
// private final class ActualTrimDropTarget implements IDropTarget2 {
// public IWindowTrim draggedTrim;
//
// // tracking parameters
// private DragBorder border = null;
// private int dockedArea;
//
// // Holder for the position of trim that is 'floating' with the cursor
// private int cursorAreaId;
// private int initialAreaId;
// private IWindowTrim initialInsertBefore;
// private Rectangle initialLocation;
//
// /**
// * Constructor
// */
// private ActualTrimDropTarget() {
// super();
//
// draggedTrim = null;
// dockedArea = SWT.NONE;
//
// initialAreaId = SWT.NONE;
// initialInsertBefore = null;
// }
//
// /**
// * This method is used to delineate separate trims dragging events. The -first- drag
// * event will set this and then it will remain constant until the drag gesture is done;
// * either by dropping or escaping. Once the gesture is finished the trim value is set
// * back to 'null'.
// *
// * @param trim The trim item currently being dragged.
// */
// public void startDrag(IWindowTrim trim) {
// // Are we starting a new drag?
// if (draggedTrim != trim) {
// // remember the dragged trim
// draggedTrim = trim;
//
// // Remember the location that we were in initially so we
// // can go back there on an cancel...
// initialAreaId = layout.getTrimAreaId(draggedTrim.getControl());
//
// // Determine who we were placed 'before' in the trim
// initialInsertBefore = getInsertBefore(initialAreaId, draggedTrim);
//
// // Remember the location that the control used to be at for animation purposes
// initialLocation = DragUtil.getDisplayBounds(draggedTrim.getControl());
//
// // The dragged trim is always initially docked
// dockedArea = initialAreaId;
// }
// }
//
// /**
// * Determine the trim area from the point. To avoid clashing at the 'corners' due to extending the trim area's
// * rectangles we first ensure that the point is not actually -within- a trim area before we check the extended
// * rectangles.
// *
// * @param pos The current cursor pos
// * @return the Trim area that the cursor is in or SWT.NONE if the point is not in an area
// */
// private int getTrimArea(Point pos) {
// // First, check if we're actually -within- a trim area (i.e. no boundary extensions)
// int areaId = getTrimArea(pos, 0);
//
// // If we are not inside a trim area...are we 'close' to one?
// if (areaId == SWT.NONE) {
// areaId = getTrimArea(pos, TrimDragPreferences.getThreshold());
// }
//
// // not inside any trim area
// return areaId;
// }
//
// /**
// * Checks the trims areas against the given position. Each trim area is 'extended' into
// * the workbench page by the value of <code>extendedBoundaryWidth</code> before the checking
// * takes place.
// *
// * @param pos The point to check against
// * @param extendedBoundaryWidth The amount to extend the trim area's 'inner' edge by
// *
// * @return The trim area or SWT.NONE if the point is not within any extended trim area's rect.
// */
// private int getTrimArea(Point pos, int extendedBoundaryWidth) {
// int[] areaIds = layout.getAreaIds();
// for (int i = 0; i < areaIds.length; i++) {
// Rectangle trimRect = layout.getTrimRect(windowComposite, areaIds[i]);
// trimRect = Geometry.toControl(windowComposite, trimRect);
//
// // Only check 'valid' sides
// if ( (areaIds[i] & getValidSides()) != SWT.NONE) {
// // TODO: more confusion binding 'areaIds' to SWT 'sides'
// switch (areaIds[i]) {
// case SWT.LEFT:
// trimRect.width += extendedBoundaryWidth;
//
// if (pos.y >= trimRect.y &&
// pos.y <= (trimRect.y+trimRect.height) &&
// pos.x <= (trimRect.x+trimRect.width)) {
// return areaIds[i];
// }
// break;
// case SWT.RIGHT:
// trimRect.x -= extendedBoundaryWidth;
// trimRect.width += extendedBoundaryWidth;
//
// if (pos.y >= trimRect.y &&
// pos.y <= (trimRect.y+trimRect.height) &&
// pos.x >= trimRect.x) {
// return areaIds[i];
// }
// break;
// case SWT.TOP:
// trimRect.height += extendedBoundaryWidth;
//
// if (pos.x >= trimRect.x &&
// pos.x <= (trimRect.x+trimRect.width) &&
// pos.y <= (trimRect.y+trimRect.height)) {
// return areaIds[i];
// }
// break;
// case SWT.BOTTOM:
// trimRect.y -= extendedBoundaryWidth;
// trimRect.height += extendedBoundaryWidth;
//
// if (pos.x >= trimRect.x &&
// pos.x <= (trimRect.x+trimRect.width) &&
// pos.y >= trimRect.y) {
// return areaIds[i];
// }
// break;
// }
// }
// }
//
// // not inside any trim area
// return SWT.NONE;
// }
//
// /**
// * Determine the window trim that the currently dragged trim should be inserted
// * before.
// * @param areaId The area id that is being checked
// * @param pos The position used to determine the correct insertion trim
// * @return The trim to 'dock' the draggedTrim before
// */
// private IWindowTrim getInsertBefore(int areaId, Point pos) {
// boolean isHorizontal = (areaId == SWT.TOP) || (areaId == SWT.BOTTOM);
//
// // Walk the trim area and return the first one that the positon
// // is 'after'.
// List tDescs = layout.getTrimArea(areaId).getDescriptors();
// for (Iterator iter = tDescs.iterator(); iter.hasNext();) {
// TrimDescriptor desc = (TrimDescriptor) iter.next();
//
// // Skip ourselves
// if (desc.getTrim() == draggedTrim) {
// continue;
// }
//
// // Now, check
// Rectangle bb = desc.getCache().getControl().getBounds();
// Point center = Geometry.centerPoint(bb);
// if (isHorizontal) {
// if (pos.x < center.x) {
// return desc.getTrim();
// }
// }
// else {
// if (pos.y < center.y) {
// return desc.getTrim();
// }
// }
// }
//
// return null;
// }
//
// /**
// * Returns the trim that is 'before' the given trim in the given area
// *
// * @param areaId The areaId of the trim
// * @param trim The trim to find the element after
// *
// * @return The trim that the given trim is 'before'
// */
// private IWindowTrim getInsertBefore(int areaId, IWindowTrim trim) {
// List tDescs = layout.getTrimArea(areaId).getDescriptors();
// for (Iterator iter = tDescs.iterator(); iter.hasNext();) {
// TrimDescriptor desc = (TrimDescriptor) iter.next();
// if (desc.getTrim() == trim) {
// if (iter.hasNext()) {
// desc = (TrimDescriptor) iter.next();
// return desc.getTrim();
// }
// return null;
// }
// }
//
// return null;
// }
//
// /**
// * Recalculates the drop information based on the current cursor pos.
// *
// * @param pos The cursor position
// */
// public void track(Point pos) {
// // Convert the mouse positon into 'local' coords
// Rectangle r = new Rectangle(pos.x, pos.y, 1,1);
// r = Geometry.toControl(windowComposite, r);
// pos.x = r.x;
// pos.y = r.y;
//
// // Are we 'inside' a trim area ?
// cursorAreaId = getTrimArea(pos);
//
// // Provide tracking for the appropriate 'mode'
// if (cursorAreaId != SWT.NONE) {
// trackInsideTrimArea(pos);
// } else {
// trackOutsideTrimArea(pos);
// }
// }
//
// /**
// * Perform the feedback used when the cursor is 'inside' a particular trim area.
// * The current implementation will place the dragged trim into the trim area at
// * the location determined by the supplied point.
// *
// * @param pos The point to use to determine where in the trim area the dragged trim
// * should be located.
// */
// private void trackInsideTrimArea(Point pos) {
// // Where should we be?
// int newArea = getTrimArea(pos);
// IWindowTrim newInsertBefore = getInsertBefore(newArea, pos);
//
// // if we're currently undocked then we should dock
// boolean shouldDock = dockedArea == SWT.NONE;
//
// // If we're already docked then only update if there's a change in area or position
// if (dockedArea != SWT.NONE) {
// // Where are we now?
// IWindowTrim curInsertBefore = getInsertBefore(dockedArea, draggedTrim);
//
// // If we're already docked we should only update if there's a change
// shouldDock = dockedArea != newArea || curInsertBefore != newInsertBefore;
// }
//
// // Do we have to do anything?
// if (shouldDock) {
// // (Re)dock the trim in the new location
// dock(newArea, newInsertBefore);
// }
// }
//
// /**
// * Provide the dragging feedback when the cursor is -not- explicitly inside
// * a particular trim area.
// *
// */
// private void trackOutsideTrimArea(Point pos) {
// // If we -were- docked then undock
// if (dockedArea != SWT.NONE) {
// undock();
// }
//
// border.setLocation(pos, SWT.BOTTOM);
// }
//
// /**
// * Return the set of valid sides that a piece of trim can be docked on. We
// * arbitrarily extend this to include any areas that won't cause a change in orientation
// *
// * @return The extended drop 'side' set
// */
// private int getValidSides() {
// int result = draggedTrim.getValidSides();
// if (result == SWT.NONE) {
// return result;
// }
//
// // For now, if we can dock...we can dock -anywhere-
// return SWT.TOP | SWT.BOTTOM | SWT.LEFT | SWT.RIGHT;
// }
//
// /**
// * The user either cancelled the drag or tried to drop the trim in an invalid
// * area...put the trim back in the last location it was in
// */
// private void redock() {
// // Since the control might move 'far' we'll provide an animation
// Rectangle startRect = DragUtil.getDisplayBounds(draggedTrim.getControl());
// RectangleAnimation animation = new RectangleAnimation(
// windowComposite.getShell(), startRect, initialLocation, 300);
// animation.schedule();
//
// dock(initialAreaId, initialInsertBefore);
// }
//
// /* (non-Javadoc)
// * @see org.eclipse.ui.internal.dnd.IDropTarget#drop()
// */
// public void drop() {
// // If we aren't docked then restore the initial location
// if (dockedArea == SWT.NONE) {
// redock();
// }
// }
//
// /**
// * Remove the trim frmo its current 'docked' location and attach it
// * to the cursor...
// */
// private void undock() {
// // Remove the trim from the layout
// layout.removeTrim(draggedTrim);
// LayoutUtil.resize(draggedTrim.getControl());
//
// // Re-orient the widget to its -original- side and size
// draggedTrim.dock(initialAreaId);
// draggedTrim.getControl().setSize(initialLocation.width, initialLocation.height);
//
// // Create a new dragging border onto the dragged trim
// // Special check for TrimPart...should be generalized
// boolean wantsFrame = !(draggedTrim instanceof TrimToolBarBase);
// border = new DragBorder(windowComposite, draggedTrim.getControl(), wantsFrame);
//
// dockedArea = SWT.NONE;
// }
//
// /**
// * Return the 'undocked' trim to its previous location in the layout
// */
// private void dock(int areaId, IWindowTrim insertBefore) {
// // remove the drag 'border'
// if (border != null) {
// border.dispose();
// border = null;
// }
//
// // Update the trim's orientation if necessary
// draggedTrim.dock(areaId);
//
// // Add the trim into the layout
// layout.addTrim(areaId, draggedTrim, insertBefore);
// LayoutUtil.resize(draggedTrim.getControl());
//
// // Remember the area that we're currently docked in
// dockedArea = areaId;
// }
//
// /* (non-Javadoc)
// * @see org.eclipse.ui.internal.dnd.IDropTarget#getCursor()
// */
// public Cursor getCursor() {
// // If the trim isn't docked then show the 'no smoking' sign
// if (cursorAreaId == SWT.NONE) {
// return windowComposite.getDisplay().getSystemCursor(SWT.CURSOR_NO);
// }
//
// // It's docked; show the four-way arrow cursor
// return windowComposite.getDisplay().getSystemCursor(SWT.CURSOR_SIZEALL);
// }
//
// /* (non-Javadoc)
// * @see org.eclipse.ui.internal.dnd.IDropTarget#getSnapRectangle()
// */
// public Rectangle getSnapRectangle() {
// // TODO: KLUDGE!! We don't want to show -any- snap rect
// // but Tracker won't allow that so place it where it won't be visible
// return new Rectangle(100000, 0,0,0);
// }
//
// /* (non-Javadoc)
// * @see org.eclipse.ui.internal.dnd.IDropTarget2#dragFinished(boolean)
// */
// public void dragFinished(boolean dropPerformed) {
// // If we didn't perform a drop then restore the original position
// if (!dropPerformed && dockedArea == SWT.NONE) {
// // Force the dragged trim back into its original position...
// redock();
// }
//
// // Set the draggedTrim to null. This indicates that we're no longer
// // dragging the trim. The first call to the TrimDropTarget's 'drag' method
// // will reset this the next time a drag starts.
// draggedTrim = null;
// }
// }
//
// private ActualTrimDropTarget dropTarget;
//
// private TrimLayout layout;
// private Composite windowComposite;
//
// /**
// * Create a new drop target capable of accepting IWindowTrim items
// *
// * @param someComposite The control owning the TrimLayout
// * @param theWindow the workbenchWindow
// */
// public TrimDropTarget(Composite someComposite, WorkbenchWindow theWindow) {
// layout = (TrimLayout) someComposite.getLayout();
// windowComposite = someComposite;
//
// // Create an instance of a drop target to use
// dropTarget = new ActualTrimDropTarget();
// }
//
// /* (non-Javadoc)
// * @see org.eclipse.ui.internal.dnd.IDragOverListener#drag(org.eclipse.swt.widgets.Control, java.lang.Object, org.eclipse.swt.graphics.Point, org.eclipse.swt.graphics.Rectangle)
// */
// public IDropTarget drag(Control currentControl, Object draggedObject,
// Point position, final Rectangle dragRectangle) {
//
// // Have to be dragging trim
// if (!(draggedObject instanceof IWindowTrim)) {
// return null;
// }
//
// // OK, we're dragging trim. is it from -this- shell?
// IWindowTrim trim = (IWindowTrim) draggedObject;
// if (trim.getControl().getShell() != windowComposite.getShell()) {
// return null;
// }
//
// // If this is the -first- drag then inform the drop target
// if (dropTarget.draggedTrim == null) {
// dropTarget.startDrag(trim);
// }
//
// // Forward on to the 'actual' drop target for feedback
// dropTarget.track(position);
//
// // Spin the paint loop after every track
// windowComposite.getDisplay().update();
//
// return dropTarget;
// }
//}